/**
 * 项目基类
 */
(function() {
	this.project = {
		version : '0.1.1',
		options : {
			//操作标签，自定义的dom属性
			operationTag : 'handler' ,
			//高亮显示的class类
			activeClass : 'current' ,
			urlTag : 'url'
		},
		//系统路径
		path : '/',
		seesionId : ''
	} ;
	
	/**
	 * project工具类 motools prototype
	 */
	this.project.Tools = new Class({
		Implements : [ Options, Events ],

		initialize : function(options) {
			this.setOptions(options);
		},
		/**
		 * 判断是否为数组
		 */
		isArray: function(arr) {
			return Object.prototype.toString.apply(arr) === "[object Array]";
		}
	});
	//初始化工具类
	project.tools = new project.Tools() ;
	/**
	 * 基类
	 */
	this.project.Base = new Class({
		Implements : [ Options, Events ],
		
		options : {
			imagePathTemplate : '{basePath}/sharefile/image/{imagepath}.do' 
		},

		initialize : function(options) {
			this.setOptions(options);
		},
		/**
		 * 初始化项目根路径，在初始化类时调用
		 */
		initBasePath : function(){
			//由dom元素中获取项目路径
			project.basePath = "/" ;
		},
		/**
		 * 获取地址栏中的请求参数
		 */
		getQueryParam : function(name){
		     var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)");
		     var r = window.location.search.substr(1).match(reg);
		     if(r!=null){
		    	 return  unescape(r[2]); 
		     }
		     return null;
		},
		/**
		 * 使用data数据填充template，并返回经过数据填充后的模板。
		 * 例如：模板：<tr>{filename}</tr>，数据：{filename:'文件名称'}
		 */
		renderTemplate : function(template , data){
			var renderTemplate = String(template) ;
			//为填充数据添加basePath属性
			data = $.extend(data , {
				basePath : project.basePath
			}) ;
			
			for ( var key in data) {
				renderTemplate = renderTemplate.replace(new RegExp('\{'+key+'\}',"gm") , data[key]) ;
			}
			return renderTemplate ;
		},

		initDisabledBtn:function(select,dis){
			var obj = {
				btn:$(select),
				isDis:function(){
					if(this.btn&&this.btn.attr("disBtn")){
						return true;
					}else{
						return false;
					}
				},
				rmDis:function(){
					if(this.btn){
						this.btn.removeAttr("disBtn");
						return true;
					}else{
						return false;
					}
				},
				setDis:function(){
					if(this.btn){
						this.btn.attr("disBtn",true);
						return true;
					}else{
						return false;
					}
				},
				isDisAndSet:function(){
					if(this.isDis()){
						return true;
					}else{
						this.setDis();
						return false;
					}
				}
			};
			if(dis){
				obj.setDis();
			}else if(dis==false){
				obj.rmDis();
			}
			return obj;
		}
	});
	/**
	 * 无限级菜单。构造无限级菜单的数据结构。通过js模板引擎渲染菜单模板数据
	 */
	this.project.TreeData = new Class({
		Extends : project.Base ,
		
		options : {
			//菜单节点id
			id : 'id' ,
			//菜单节点的父菜单id
			pId : 'parentId' ,
			//菜单项的排序字段
			order : 'sort' ,
			//子节点数组
			child : 'childs' 
		},
		
		/**
		 * 初始化菜单 , simpleData可以是数组字符串也可以是数组，itemHandler是对每个item的处理函数
		 * 返回树形结构的数组数据。
		 */
		init : function(simpleData , itemHandler) {
			if(!simpleData){
				return ;
			}
			var currobj = this ;
			var dataArray = [] ;
			//如果为数组文本，转换为数组；否则直接使用
			if(!project.tools.isArray(simpleData)){
				dataArray = eval('('+simpleData+')') ;
			}else{
				dataArray = simpleData ;
			}
			//菜单树根节点数组
			var treeData = [];
			var tmpMap = {} ;
			for (i=0, l=dataArray.length; i<l; i++) {
				tmpMap[dataArray[i][currobj.options.id]] = dataArray[i];
			}
			//构建属性结构菜单
			for (i=0, l=dataArray.length; i<l; i++) {
				if (tmpMap[dataArray[i][currobj.options.pId]] && dataArray[i][currobj.options.id] != dataArray[i][currobj.options.pId]) {
					if(!tmpMap[dataArray[i][currobj.options.pId]][currobj.options.child]){
						tmpMap[dataArray[i][currobj.options.pId]][currobj.options.child] = [] ;
					}
					tmpMap[dataArray[i][this.options.pId]][this.options.child].push(dataArray[i]);
				} else {
					treeData.push(dataArray[i]) ;
				}
			}
			
			currobj.afterHandler(treeData , itemHandler) ;
			
			return treeData ;
		} ,
		/**
		 * 菜单排序函数，按从小到大排序
		 */
		sortFn : function(item1 , item2){
			var sort1 = isNaN(item1[this.options.order]) ? Number.MAX_VALUE : Number(item1[this.options.order]) ;
			var sort2 = isNaN(item2[this.options.order]) ? Number.MAX_VALUE : Number(item2[this.options.order]) ;
			
			if(sort1 > sort2){
				return 1 ;
			}
			
			return -1 ;
		} ,
		/**
		 * 遍历菜单数组元素进行排序和处理
		 */
		afterHandler : function(itemArray , itemHandler){
			var currobj = this ;
			//为空或不是数组，则退出
			if(!itemArray || !project.tools.isArray(itemArray) ||
					itemArray.length < 1){
				return ;
			}
			
			itemArray.sort(currobj.sortFn.bind(currobj)) ;
			
			//对子节点进行排序
			for (var i = 0 ; i < itemArray.length; i++) {
				//如果item项的处理函数不为空，则调用每一项进行处理
				if(itemHandler && (typeof itemHandler)=='function'){
					itemHandler(itemArray[i]) ;
				}
				(arguments.callee.bind(currobj))(itemArray[i][currobj.options.child] , itemHandler) ;
			}
		}
	});
	/**
	 * 主界面包装类
	 */
	this.project.Wrapper = new Class({
		Extends : project.Base ,
		options : {
			operationTag : project.options.operationTag,
			urlTag : project.options.urlTag,
			activeClass : project.options.activeClass ,
			//图标样式
			iconClass : {
				"ACCOUNTMGR":"setting-icon",
				"MSGCENTER":"message-icon",
				"MEMBERINTEGRAL":"memberintegral-icon",
				"TICKET":"ticket-icon",
				"SKILLTRAINING":"test-icon",
				"MYACTIVITY":"activity-icon",
				"SKILLTRAINING":"test-icon",
				"USERINDEX":"userindex-icon",
				"CPEXAM":"cpexam-icon",
				"DEALMANAGESCHOOL":"dealmanage-icon",
				"SIGNUPPAY":"dealmanage-icon",
				"INVITECENTER":"zp-icon",
				"GETJOBCENTER":"zp-icon",
				"USERNAME":"username-icon",
			},
			ticketID:'ticketID',
			matchPlatURL:'http://sspt.glodonedu.com',
			personURL:$("#basePath").val()
		},

		initialize : function(options) {
			this.setOptions(options);
			
			this.initMenu();
			
			this.initExceptionHandler() ;
			
			this.initDetails() ;
		},
		/**
		 * 初始化菜单
		 */
		initMenu : function() {
			var currobj = this;
			if(! $('#menujson') || $('#menujson').length < 1){
				return ;
			}
			//获取用户登录后的ticket身份验证唯一码
			var ticketValue = $('#'+this.options.ticketID).length <= 0 ? null : $('#'+this.options.ticketID).text();
			//存储ticket的value
			this.options.ticket = ticketValue ;

			//获取菜单的json数组
			var menujson = $('#menujson').text() ;
			//菜单树对象
			var menuTree = new project.TreeData() ;
			//当前菜单样式
			var iconClass = this.options.iconClass ;
			//获取格式化的菜单数据
			var menuData = menuTree.init(menujson , function(item){
				if(!item){
					return ;
				}
				item.icon = item.code && iconClass[item.code] ? iconClass[item.code] : '' ;

				//zhangyy-k  start
				var url = item.url;
				var urlParam = url.split('?');
				//获取参数值
				if (urlParam.length > 1) {
					//标识哪个业务系统
					var sysName = currobj.getUrlParam(url, "sysName");
					//标识所有哪个模块
					var plateName = currobj.getUrlParam(url, "plateName");
					//不带参数的URL
					var urlSelf = urlParam == null ? null : urlParam[0];
					if (sysName == 'matchPlat') {
                        item.url = currobj.options.matchPlatURL + urlSelf + '?sysName=' + sysName + '&plateName=' + plateName + '&ticket=' + ticketValue;
                    }else {
                        item.url = currobj.options.personURL + urlSelf + '?sysName=' + sysName + '&plateName=' + plateName + '&ticket=' + ticketValue;
                    }
				} else {
					//currobj.options.personURL +
					//item.url = url +'?ticket=' + ticketValue;
					item.url = url ;
                }
				//zhangyy-k  end
			}) ;
			//menuData=this.filterMenuData(menuData);

			//渲染菜单模板
			var menuHtml = template('menuTemplate' , {
				list : menuData
			}) ;
			//清楚菜单数据
			$('#menujson').remove() ;
			//移除现有的模板
			$('#menuTemplate').remove() ;
			//添加渲染后的模板到菜单区域
			$('#menuContext').html(menuHtml) ;
			
			this.highlightMenu() ;
			
			this.setMenuAnimation();
		},
		/**
		 * 根据参数名字获取url参数值
		 * @param paramName
		 */
		getUrlParam:function(url,paramName){
			var reg
				= new RegExp("(^|&?)"+
				paramName +"=([^&]*)(&|$)");
			var r
				= url.substr(1).match(reg);
			if (r!=null) return unescape(r[2]); return null;
		},
		/**
		 * 设置鼠标移动到菜单的动画效果
		 */
		setMenuAnimation:function(){
			$(".titleright li").mouseenter(function(){
				$(this).addClass("active");
				});
			$(".titleright li").mouseleave(function(){
				$(this).removeClass("active");
				});

			$(".titleright li.active").mouseenter(function(){
				$(this).addClass("active");
				});
			$(".titleright li.active").mouseleave(function(){
				$(this).addClass("active");
				});
		},
		/**
		 * 过滤显示的菜单
		 * 匹配exam，authentication，others..的url显示不同类别的菜单
		 */
		filterMenuData:function(menuData){
			var exam='/examList' ;
			var auth='/authentication' ;
			var filter='';
			var currpath = window.location.pathname;
			var tpl='<li class="-cls-"><a href="url">name</a></li>';
			if(currpath.contains(exam)){
				filter=exam;
			}else if(currpath.contains(auth)){
				filter=auth;
			}
			var arr=new Array();
			if(typeof(menuData)!='undefined'&&menuData!=null){
				var s1=100,s2=100,s3=100,m1={active:'inactive',url:''},m2={active:'inactive',url:''},m3={active:'inactive',url:''};//base 1,exam 2,auth 3设置横向菜单的跳转地址地址
				$.each(menuData,function(index,data){
					if(filter!=''){
						if(data.url.contains(filter)){
							arr.push(data);
							if(filter==exam){
								m2.active='active';
							}
							if(filter==auth){
								m3.active='active';
							}
						}
					}
					else{
						if(!data.url.contains(exam)&&!data.url.contains(auth)){
							arr.push(data);
							m1.active='active';
						}
					}
					if(data.url.contains(exam)){
						if(data.sort<s2){
							s2=data.sort;
							m2.url=data.url;
						}
					}else if(data.url.contains(auth)){
						if(data.sort<s3){
							s3=data.sort;
							m3.url=data.url;
						}
					}else{
						if(data.sort<s1){
							s1=data.sort;
							m1.url=data.url;
						}
					}
				});
				var basePath=$("#basePath").val();
				var hmenu= $("#hmenuContainer ul");
				if(m1.url!=''){
					hmenu.append(tpl.replace('name', '我的广联达').replace('url',basePath+m1.url).replace('-cls-', m1.active));
				}
				if(m2.url!=''){
					hmenu.append(tpl.replace('name', '测评考试').replace('url',basePath+m2.url).replace('-cls-', m2.active));
				}
				if(m3.url!=''){
					hmenu.append(tpl.replace('name', '认证考试').replace('url',basePath+m3.url).replace('-cls-', m3.active));
				}
			}
			return arr;
		},
		/**
		 * 高亮显示当前菜单项
		 */
		highlightMenu : function(){
			//获取当前项目路径
			var currpath = window.location.pathname ;
            if(currpath.lastIndexOf('index.do')>0){
                return;
            }
			//url请求路径用"/"进行分割
			var pathkeys = currpath.split('/') ;
			//查找所有的菜单项
			var menuItems = $('#menuContext').find('a') ;
			var bestMenuIndex = -1 ;
			var maxLength = -1 ;
			//查找匹配当前请求路径最匹配的菜单项
			for (var i = 0; i < menuItems.length; i++) {
				var menuItem = menuItems[i] ;
				var url = $(menuItem).attr('href') ;
				//临时匹配索引位置
				var tempMatchLength = -1 ;
				//按路径关键字匹配最佳的菜单项
				for (var j = 0; j < pathkeys.length; j++) {
					if(pathkeys[j].length<1){
						continue ;
					}
					//截取当前页面的url
					var subkey = pathkeys.slice(0 , j+1).join("/") ;
					if(url.indexOf(subkey)>-1){
						tempMatchLength = subkey.length ;
					}else{
						break ;
					}
				}
				//更新匹配的菜单项
				if(tempMatchLength!=-1&&tempMatchLength>=maxLength){
					maxLength = tempMatchLength ;
					bestMenuIndex = i ;
				}
			}
			//没有找到匹配的菜单项
			if(bestMenuIndex==-1){
				return ;
			}
			var bestMenuItem = menuItems[bestMenuIndex] ;
			//为当前菜单项添加高亮样式
			$(bestMenuItem).addClass('active');
			//如果存在父菜单，则为父菜单添加高亮样式
			var submenu =  $(bestMenuItem).parents('.sub-menu') ;
			if(submenu && submenu.length>0){
				submenu.siblings('.title').find('a').addClass('active');
			}
		},
		/**
		 * 单个页面初始化函数
		 */
		initDetails : function() {
		},
		/**
		 * 初始化异常处理
		 */
		initExceptionHandler : function(){
			$.ajaxSetup({
				error: function(jqXHR, textStatus, errorThrown){
					//以json格式解析返回的错误信息
					try {
						var data = JSON.parse(jqXHR.responseText) ;
					}catch (e){

					}

					if(typeof(data)!='undefined'&&data!=null && typeof(data.message)!='undefined'&&data.message!=null)
					{
						$.error({
							content : data.message,
							ok:function(){
								if(typeof(data.loginurl)!='undefined'&&data.loginurl!=null)
								{
									location.href=project.basePath+data.loginurl;
								}
							}
						}) ;	
					}else{
						//根据是否是系统捕获并处理过的异常，设置异常提示信息
						var message = null ;
						if(data&&data.iscatched){
							message = data.message ;
						}else{
							message = '系统内部错误' ;
						}
						$.error({
							content : message
						}) ;
					}
				}
			});
		}
	});
	/**
	 * 分页类
	 */
	this.project.Page = new Class({
		Extends : project.Base ,
		options : {
			//分页组件容器id
			container_id : "pagination" ,
			//分页号组件id，分页号组件为input
			pagenum_id : "pagination_pagenum",
			//每页大小组件id，每页大小组件为input
			pagesize_id : "pagination_pagesize" ,
			//所有元素组件id，所有元素组件为input
			totalelements_id : "pagination_totalelements" 
		} ,
		initialize : function(options) {
			this.setOptions(options);
			this.init() ;
		},
		/**
		 * 初始化分页插件
		 */
		init : function(){
			var paginationId = "#"+this.options.container_id ;
			//检查是否加载完成了jquery分页组件pagination
			if($(paginationId).length<1 || !$(paginationId).pagination){
				return ;
			}
			//每次点击对调函数
			var callbackFn = function(pageNum , pageContainer){
				//对请求的同一页，不重复设置
				var pagenumId = "#"+this.options.pagenum_id ;
				if(Number($(pagenumId).val())==Number(pageNum)){
					return ;
				}
				//后台分页号由0开始
				$(pagenumId).val(Number(pageNum)) ;
				//出发分页号的click事件
				$(pagenumId).trigger("click") ;
			}.bind(this) ;
			//分别获取所有记录数、每页最大记录数和当前页号
			var totalelements = this.getPageTotalElements() ;
			var pagesize = this.getPageSize() ;
			var pagenum = this.getPageNum() ;
			//分页插件属性配置
			var optInit = {
				items_per_page : pagesize ,
				num_display_entries : 5 ,
				num_edge_entries : 2 ,
				prev_text : "上一页" ,
				next_text : "下一页" ,	
				current_page : pagenum ,
				callback : callbackFn ,
				prev_show_always : false ,
				next_show_always : false
			};
			//只覆盖分页插件中自定义的属性
			for ( var optKey in optInit) {
				if(this.options[optKey]){
					optInit[optKey] = this.options[optKey] ;
				}
			}
			$(paginationId).pagination(totalelements , optInit);
		},
		/**
		 * 返回当前页号或待分页的号，默认返回第一页,pagination默认分页起始号为0
		 */
		getPageNum : function(){
			var pagenumId = "#"+this.options.pagenum_id ;
			var pagenum = $(pagenumId).val() ;
			//如果不是数字，则由0开始
			if(isNaN(pagenum)||$.trim(pagenum).length<1){
				return 0 ;
			}
			return pagenum ;
		},
		/**
		 * 返回每页最大记录数
		 */
		getPageSize : function(){
			var pagensizeId = "#"+this.options.pagesize_id ;
			var pagensize = $(pagensizeId).val() ;
			//如果不是数字，则由0开始
			if(isNaN(pagensize)||$.trim(pagensize).length<1){
				return 0 ;
			}
			return pagensize ;
		} ,
		/**
		 * 返回每页最大记录数
		 */
		getPageTotalElements : function(){
			var totalelementsId = "#"+this.options.totalelements_id ;
			var totalelements = $(totalelementsId).val() ;
			//如果不是数字，则由0开始
			if(isNaN(totalelements)||$.trim(totalelements).length<1){
				return 0 ;
			}
			return totalelements ;
		} ,
		/**
		 * 获取分页请求参数，包括分页号，默认不包含每页大小和所有记录数
		 */
		getPageParam : function(includePageSize , incluceTotalNum){
			var param = {
				pagenum : this.getPageNum()
			};
			
			if(Boolean(includePageSize)){
				param.pagesize = this.getPageSize() ;
			}
			
			if(Boolean(incluceTotalNum)){
				param.totalelements = this.getPageTotalElements() ;
			}
			
			return param;
		},
		/**
		 * 清理分页插件的参数
		 */
		clearPageParam : function(includePageSize , incluceTotalNum){
			//清理分页号
			var pagenumId = "#"+this.options.pagenum_id ;
			$(pagenumId).val("") ;
		}
	}) ;
	/**
	 * 上传组件类
	 */
	this.project.Upload = new Class({
		Extends : project.Base ,
		options : {
			fileObjName	  : "file" ,
			queueID		  : "_fileQueue_no",
			hideButton	  : true,
			//默认上传大小为5MB
			fileSizeLimit : "5MB",
	        buttonText    : "上传文件" ,
	        buttonImage   : null ,
	        auto		  : true ,
	        multi 		  : false ,
	        //上传参数，字符串
	        param : null 
		},
		initialize : function(customOptions) {

			//和系统路径相关的属性，单独初始化
			this.options.uploader = project.basePath+'/sharefile/upload.do' ;
			this.options.swf = project.basePath+'/resources/plugins/uploadify/uploadify.swf' ;
			this.options.cancelImg = project.basePath+'/resources/plugins/uploadify/uploadify-cancel.png' ;
			//上传进度信息
			this.options.onUploadProgress = function(file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) {
	        };
			//合并用户自定义属性和默认属性
			this.setOptions(customOptions) ;
			//options对function的属性不支持 ， 使用$.extend扩展对options的支持
			$.extend(this.options , customOptions) ;
			//将参数构造到url中
			if(this.options.param){
				this.options.uploader = String(this.options.uploader) ;
				var endMark = this.options.uploader.substring(this.options.uploader.length-1) ;
				if(endMark!='?'){
					this.options.uploader += '?' ;
				}
				this.options.uploader += this.options.param ;
			}
		},
		/**
		 * 初始化上传组件
		 */
		init : function(uploadBtnId){
			$("#"+uploadBtnId).uploadify(this.options);
		}
	}) ;

	/**
	 * 上传组件类
	 */
	this.project.UploadTwo = new Class({
		Extends : project.Base ,
		options : {
			fileObjName	  : "file" ,
			queueID		  : "_fileQueue_no",
			hideButton	  : true,
			//默认上传大小为5MB
			fileSizeLimit : "4MB",
			buttonText    : "选择照片" ,
			buttonImage   : null ,
			auto		  : true ,
			multi 		  : false ,
			//上传参数，字符串
			param : null
		},
		initialize : function(customOptions) {
			//和系统路径相关的属性，单独初始化
			this.options.uploader = project.basePath+'/rzds/team/upload' ;
			this.options.swf = project.basePath+'/resources/plugins/uploadify/uploadify.swf' ;
			this.options.cancelImg = project.basePath+'/resources/plugins/uploadify/uploadify-cancel.png' ;
			//上传进度信息
			this.options.onUploadProgress = function(file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) {
			};
			//合并用户自定义属性和默认属性
			this.setOptions(customOptions) ;
			//options对function的属性不支持 ， 使用$.extend扩展对options的支持
			$.extend(this.options , customOptions) ;
			//将参数构造到url中
			if(this.options.param){
				this.options.uploader = String(this.options.uploader) ;
				var endMark = this.options.uploader.substring(this.options.uploader.length-1) ;
				if(endMark!='?'){
					this.options.uploader += '?' ;
				}
				this.options.uploader += this.options.param ;
			}
		},
		/**
		 * 初始化上传组件
		 */
		init : function(uploadBtnId){
			if($.fn.uploadify){
				$("#"+uploadBtnId).uploadify(this.options);
			}
		}
	}) ;


	/**
	 * 上传组件类
	 */
	this.project.UploadTeapic = new Class({
		Extends : project.Base ,
		options : {
			fileObjName	  : "file" ,
			queueID		  : "_fileQueue_no",
			hideButton	  : true,
			//默认上传大小为5MB
			fileSizeLimit : "5MB",
			buttonText    : "上传文件" ,
			buttonImage   : null ,
			auto		  : true ,
			multi 		  : false ,
			//上传参数，字符串
			param : null
		},
		initialize : function(customOptions) {

			//和系统路径相关的属性，单独初始化
			this.options.uploader = project.basePath+'/sharefile/uploadteapic.do' ;
			this.options.swf = project.basePath+'/resources/plugins/uploadify/uploadify.swf' ;
			this.options.cancelImg = project.basePath+'/resources/plugins/uploadify/uploadify-cancel.png' ;
			//上传进度信息
			this.options.onUploadProgress = function(file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) {
			};
			//合并用户自定义属性和默认属性
			this.setOptions(customOptions) ;
			//options对function的属性不支持 ， 使用$.extend扩展对options的支持
			$.extend(this.options , customOptions) ;
			//将参数构造到url中
			if(this.options.param){
				this.options.uploader = String(this.options.uploader) ;
				var endMark = this.options.uploader.substring(this.options.uploader.length-1) ;
				if(endMark!='?'){
					this.options.uploader += '?' ;
				}
				this.options.uploader += this.options.param ;
			}
		},
		/**
		 * 初始化上传组件
		 */
		init : function(uploadBtnId){
			$("#"+uploadBtnId).uploadify(this.options);
		}
	}) ;

	/**
	 * project注册中心类，用于维护在上下文中注册的实体
	 */
	this.project.Dispatcher = new Class({
		Implements : [ Options, Events ],

		initialize : function(options) {
			this.setOptions(options);
		},
		/**
		 * 当前索引号
		 */
		currIndex : 1 ,
		/**
		 * 下一个索引号
		 */
		nextIndex : function(){
			return this.currIndex++ ;
		},
		/**
		 * 获取已经注册的映射
		 */
		registerMap : {
			
		} ,
		/**
		 * 注册key<->value对
		 */
		register : function(key , obj){
			this.registerMap[key] = obj ;
		} , 
		/**
		 * 根据key获取注册的对象，如果没有注册返回null
		 */
		getRegisterObj : function(key){
			if(this.registerMap[key]){
				return this.registerMap[key] ;
			}
			return null ;
		}
	});
	//存储当前页面注册的处理类
	var dispatcher = new project.Dispatcher() ;
	/**
	 * 使前端代码和js逻辑的最大程度的解耦，解决在开发过程中js代码和dom元素绑定混乱问题；
	 * 使用基于JS面向对象方式，增强JS代码的可维护性。
	 */
	this.project.Details = new Class({
		Extends : project.Base ,
		options : {
			operationTag : project.options.operationTag ,
			urlTag : project.options.urlTag ,
			activeClass : project.options.activeClass ,
			//在初始化的时候指定类名称
			className : 'class_'+dispatcher.nextIndex() ,
			pageAttribute : "page"
		},
		//当前类的构造函数
		initialize : function(options) {
			this.setOptions(options);
			//注册当前类到派发中心
			this.register(this.options.className) ;
			this.init() ;
		},
		/**
		 * 注册当前类到派发器dispatcher
		 */
		register : function(key){
			dispatcher.register(key , this) ;
		},
		/**
		 * 初始化系统
		 */
		init : function(){
			this.initBasePath() ;
			
			this.initAjax() ;
			
			this.initHandlers() ;
			
			this.initDetails() ;
		},
		/**
		 * 初始化ajax配置，在初始化类时调用
		 */
		initAjax : function(){
			$.ajaxSetup({
			  type : "POST" ,
			  cache : false 
			});
			//ajax请求后绑定新加的dom
			$(document).ajaxComplete(function(event, xhr, settings) {
				this.initHandlers() ;
			}.bind(this));
		},
		/**
		 * 初始化绑定operationTag标签对应的处理函数，在初始化类和每次ajax请求后自动调用
		 */
		initHandlers : function() {
			var operationTag = this.options.operationTag;
			//使用正则表达式获取处理函数调用者、函数名称和参数
			var handlerReg = /(\w+\.)*(\w+)(\(.*\))*/ ;
			var currentObj = this;
			//没有绑定函数的处理
//			var noBindFnHandler = function(message){
//				alert('a') ;
//			};
			//查找具有operationTag的dom元素，将operationTag值与当前类中对应函数绑定
			$('body').find('[' + operationTag + ']').each(function(i, dom) {
				// 使用dom的属性监测是否在dom上已经绑定了click事件
				if (!$(dom).data("hasClickHandler")) {
					var regResult = handlerReg.exec(String($(dom).attr(operationTag)));
					var handlerClass = regResult[1] ;
					var handlerName = regResult[2] ;
					var handlerParam = regResult[3] ;
					//默认的函数调用者为声明的当前对象
					var handlerObj = null ;
					//获取方法映射类
					if(handlerClass){
						handlerObj = dispatcher.getRegisterObj(String(handlerClass).substring(0, handlerClass.length-1)) ;
					}else{
						handlerClass = '' ;
						//默认的绑定对象时当前类中
						handlerObj = currentObj ;
					}
					//格式化方法参数
					if(handlerParam){
						handlerParam = String(handlerParam).substring(1, handlerParam.length-1) ;
					}
					//解除已有的点击事件绑定
//					$(dom).unbind("click" , noBindFnHandler) ;
					//查找是否有对应的绑定方法，如果没有则不绑定
					if(!handlerObj || !handlerObj[handlerName]){
//						$(dom).click(noBindFnHandler);
//						.bind(null,'没有找到要绑定的处理函数'+handlerClass+handlerName)
						return ;
					}
					//如果没有找到要绑定的函数，则不绑定，同时也不设置事件绑定标识hasClickHandler
					$(dom).click(function(event) {
						//由当前对象中获取handler对应的函数名称
						var fn = handlerObj[handlerName] ;
						//获取是否禁用双击属性，只有包含disableDoubleClick属性，且值为false时才不会禁用双击
						var disableDoubleClick = 'false'!=$(dom).attr("disableDoubleClick") ;
						if(disableDoubleClick){
							$(dom).attr('disabled',true) ;
						}
						//调用对Function的扩展，执行函数，如果函数不带参数，默认的第一个参数为dom元素
						if(handlerParam){
							fn.apply(handlerObj , handlerParam.split(",").concat(dom)) ;
						}else{
							fn.apply(handlerObj , [dom] ) ;
						}
						
						if(disableDoubleClick){
							if(dom&&$(dom)&&$(dom).length){
								$(dom).attr('disabled',false) ;
							}
						}
					});
					//如果已经找到对应的绑定函数，则不再重复绑定
					$(dom).data("hasClickHandler", 1);
				}
			});
		},
		/**
		 * 初始化每个类的内容，只有在创建类的对象时调用
		 */
		initDetails : function() {
			
		} ,
		/**
		 * 初始化form验证
		 */
		initValidform : function(formId){
			//创建验证的表单对象，并存储在当前对象参数中
			this.options["validform_"+formId] = $("#"+formId).Validform({
				tiptype: 3 ,
				//验证失败后显示所有错误
				showAllError: true , 
				ajaxPost:true
			}) ;
			return this.options["validform_"+formId] ;
		},
		/**
		 * 验证表单，验证成功后执行successHandler，验证失败后执行failHandler
		 */
		checkValidform : function(formId , successHandler , failHandler){
			//获取表单验证对象
			var validForm = this.options["validform_"+formId] ;
			if(!validForm){
				validForm = this.initValidform(formId) ;
			}
			//执行表单验证
			if(validForm.check()){
				if(typeof successHandler=="function"){
					//验证成功后执行成功回调函数
					successHandler.call(this , $("#"+formId).serialize()) ;
				}
				return true ;
			}else {
				if(typeof failHandler=="function"){
					//验证成功后执行成功回调函数
					failHandler.call(this , $("#"+formId).serialize()) ;
				}
				return false ;
			}
		},
		/**
		 * 初始化分页组件，page组件在当前类中的默认属性为this.options.pageAttribute的值
		 */
		initPage : function(pageAttributeName){
			if(pageAttributeName&&$.trim(pageAttributeName).length>0){
				this.options.pageAttribute = $.trim(pageAttributeName) ;
			}
			//如果已经存在对应的分页插件，首先清理分页插件的参数信息
			var page = new project.Page() ;
			this[this.options.pageAttribute] = page ;
			return page ;
		},
		/**
		 * 获取分页请求的参数，默认属性为this.options.pageAttribute的值
		 */
		getPageRequestParam : function(pageAttributeName , type){
			//初始化在当前对象中的page属性的名称
			if(!pageAttributeName || $.trim(pageAttributeName).length<1){
				pageAttributeName = this.options.pageAttribute ;
			}
			//返回page参数，设置了type值之后返回查询参数字符串
			if(type){
				var queryStr = '' ;
				if(this[pageAttributeName]){
					var pageParam = this[pageAttributeName].getPageParam() ;
					for ( var key in pageParam) {
						if(queryStr.length>1){
							queryStr += '&' ;
						}
						queryStr += key +'='+ pageParam[key] ;
					}
				}
				return queryStr ;
			}
			//返回查询参数obj对象
			return this[pageAttributeName] ? this[pageAttributeName].getPageParam() : null ;
		},
		/**
		 * 分页点击处理
		 */
		pageNumClickHandler : function(){
			var formid = null;
			
			try{
                if (navigator.userAgent.indexOf('Firefox') >= 0){
                    formid = $(arguments).parents("form").attr("id");
                }else{
                    formid = $(event.srcElement).parents("form").attr("id");
                }

			}catch(ex){}
			
			if(formid){
				this.query(formid) ;
			}else{
				this.query(true) ;
			}
		},
		/**
		 * 执行查询
		 */
		query : function(addPageParam){
			
		},
		initPaperParam:function(){
			$("#pagination_pagenum").val('0');
		},
        checkFlash:function(msg){
            var obj=swfobject.getFlashPlayerVersion();
            if(obj.major=="0"){
                layer.confirm(msg, {
                    btn: ['去下载Falsh插件','关闭'] //按钮
                }, function(index){
                    window.open('https://get.adobe.com/cn/flashplayer/');
                    layer.close(index);
                }, function(index){
                    layer.close(index);
                });
                return false;
            }
            return true;
        },
		/**
		 * 获取form数据，返回key-value对
		 */
		getFormData : function(formId, ignoreBlankValue){
			var data = {} ;

			//form存在性校验
			if(formId && $('#'+formId).length>0){
				var fields = $('#'+formId).serializeArray();
				$.each( fields, function(i, field){
					if(!ignoreBlankValue || String(field.value).trim().length>0){
						if(data[field.name]){
							data[field.name] = data[field.name] +','+ String(field.value).trim() ;
						}else{
							data[field.name] = String(field.value).trim() ;
						}
					}
				});
			}

			return data ;
		}
	});
})();

/**
 * 初始化加载菜单项以及其它全局配置信息
 */
$(document).ready(function(){
	var wrapper = new project.Wrapper();
	//检查带有class="detailform"的dom元素，设置其中的input和textarea为只读
	var inputDoms = $('.detailform').find("input[type!='button']") ;
	inputDoms.attr("readonly" , "readonly") ;
	//textarea区域设置只读
	var textareaDoms = $('.detailform').find('textarea') ;
	textareaDoms.attr("readonly" , "readonly") ;


	$(".sub-menu").hide();
	var url = window.location.pathname;
	$("a[name='menuItem']").each(function () {
		if ($(this).attr("href") == url) {
			$(this).parents('.sub-menu').show();
		}
	});
	$(".title").click(function(){
		$(this).next('.sub-menu').animate({height: 'toggle', opacity: 'toggle'}, "slow");
	});
});